home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / AvantBrowser / asetup.exe / _data / webkit / resources.pak / Unnamed File 000119.unknown < prev    next >
Text File  |  2013-04-03  |  66KB  |  2,230 lines
  1.  
  2.  
  3.  
  4.  
  5. WebInspector.AuditsPanel = function()
  6. {
  7. WebInspector.Panel.call(this, "audits");
  8. this.registerRequiredCSS("panelEnablerView.css");
  9. this.registerRequiredCSS("auditsPanel.css");
  10.  
  11. this.createSidebarViewWithTree();
  12. this.auditsTreeElement = new WebInspector.SidebarSectionTreeElement("", {}, true);
  13. this.sidebarTree.appendChild(this.auditsTreeElement);
  14. this.auditsTreeElement.listItemElement.addStyleClass("hidden");
  15.  
  16. this.auditsItemTreeElement = new WebInspector.AuditsSidebarTreeElement(this);
  17. this.auditsTreeElement.appendChild(this.auditsItemTreeElement);
  18.  
  19. this.auditResultsTreeElement = new WebInspector.SidebarSectionTreeElement(WebInspector.UIString("RESULTS"), {}, true);
  20. this.sidebarTree.appendChild(this.auditResultsTreeElement);
  21. this.auditResultsTreeElement.expand();
  22.  
  23. this.clearResultsButton = new WebInspector.StatusBarButton(WebInspector.UIString("Clear audit results."), "clear-status-bar-item");
  24. this.clearResultsButton.addEventListener("click", this._clearButtonClicked, this);
  25.  
  26. this.viewsContainerElement = this.splitView.mainElement;
  27.  
  28. this._constructCategories();
  29.  
  30. this._launcherView = new WebInspector.AuditLauncherView(this.initiateAudit.bind(this));
  31. for (var id in this.categoriesById)
  32. this._launcherView.addCategory(this.categoriesById[id]);
  33.  
  34. WebInspector.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.OnLoad, this._didMainResourceLoad, this);
  35. }
  36.  
  37. WebInspector.AuditsPanel.prototype = {
  38. get statusBarItems()
  39. {
  40. return [this.clearResultsButton.element];
  41. },
  42.  
  43.  
  44. get categoriesById()
  45. {
  46. return this._auditCategoriesById;
  47. },
  48.  
  49.  
  50. addCategory: function(category)
  51. {
  52. this.categoriesById[category.id] = category;
  53. this._launcherView.addCategory(category);
  54. },
  55.  
  56.  
  57. getCategory: function(id)
  58. {
  59. return this.categoriesById[id];
  60. },
  61.  
  62. _constructCategories: function()
  63. {
  64. this._auditCategoriesById = {};
  65. for (var categoryCtorID in WebInspector.AuditCategories) {
  66. var auditCategory = new WebInspector.AuditCategories[categoryCtorID]();
  67. auditCategory._id = categoryCtorID;
  68. this.categoriesById[categoryCtorID] = auditCategory;
  69. }
  70. },
  71.  
  72.  
  73. _executeAudit: function(categories, resultCallback)
  74. {
  75. this._progress.setTitle(WebInspector.UIString("Running audit"));
  76.  
  77. function ruleResultReadyCallback(categoryResult, ruleResult)
  78. {
  79. if (ruleResult && ruleResult.children)
  80. categoryResult.addRuleResult(ruleResult);
  81.  
  82. if (this._progress.isCanceled())
  83. this._progress.done();
  84. }
  85.  
  86. var results = [];
  87. var mainResourceURL = WebInspector.inspectedPageURL;
  88. var categoriesDone = 0;
  89. function categoryDoneCallback()
  90. {
  91. if (++categoriesDone !== categories.length)
  92. return;
  93. this._progress.done();
  94. resultCallback(mainResourceURL, results)
  95. }
  96.  
  97. var requests = WebInspector.networkLog.requests.slice();
  98. var compositeProgress = new WebInspector.CompositeProgress(this._progress);
  99. var subprogresses = [];
  100. for (var i = 0; i < categories.length; ++i)
  101. subprogresses.push(compositeProgress.createSubProgress());
  102. for (var i = 0; i < categories.length; ++i) {
  103. var category = categories[i];
  104. var result = new WebInspector.AuditCategoryResult(category);
  105. results.push(result);
  106. category.run(requests, ruleResultReadyCallback.bind(this, result), categoryDoneCallback.bind(this), subprogresses[i]);
  107. }
  108. },
  109.  
  110.  
  111. _auditFinishedCallback: function(launcherCallback, mainResourceURL, results)
  112. {
  113. var children = this.auditResultsTreeElement.children;
  114. var ordinal = 1;
  115. for (var i = 0; i < children.length; ++i) {
  116. if (children[i].mainResourceURL === mainResourceURL)
  117. ordinal++;
  118. }
  119.  
  120. var resultTreeElement = new WebInspector.AuditResultSidebarTreeElement(this, results, mainResourceURL, ordinal);
  121. this.auditResultsTreeElement.appendChild(resultTreeElement);
  122. resultTreeElement.revealAndSelect();
  123. if (!this._progress.isCanceled())
  124. launcherCallback();
  125. },
  126.  
  127.  
  128. initiateAudit: function(categoryIds, progress, runImmediately, startedCallback, finishedCallback)
  129. {
  130. if (!categoryIds || !categoryIds.length)
  131. return;
  132.  
  133. this._progress = progress;
  134.  
  135. var categories = [];
  136. for (var i = 0; i < categoryIds.length; ++i)
  137. categories.push(this.categoriesById[categoryIds[i]]);
  138.  
  139. function startAuditWhenResourcesReady()
  140. {
  141. startedCallback();
  142. this._executeAudit(categories, this._auditFinishedCallback.bind(this, finishedCallback));
  143. }
  144.  
  145. if (runImmediately)
  146. startAuditWhenResourcesReady.call(this);
  147. else
  148. this._reloadResources(startAuditWhenResourcesReady.bind(this));
  149.  
  150. WebInspector.userMetrics.AuditsStarted.record();
  151. },
  152.  
  153. _reloadResources: function(callback)
  154. {
  155. this._pageReloadCallback = callback;
  156. PageAgent.reload(false);
  157. },
  158.  
  159. _didMainResourceLoad: function()
  160. {
  161. if (this._pageReloadCallback) {
  162. var callback = this._pageReloadCallback;
  163. delete this._pageReloadCallback;
  164. callback();
  165. }
  166. },
  167.  
  168.  
  169. showResults: function(categoryResults)
  170. {
  171. if (!categoryResults._resultView)
  172. categoryResults._resultView = new WebInspector.AuditResultView(categoryResults);
  173.  
  174. this.visibleView = categoryResults._resultView;
  175. },
  176.  
  177. showLauncherView: function()
  178. {
  179. this.visibleView = this._launcherView;
  180. },
  181.  
  182. get visibleView()
  183. {
  184. return this._visibleView;
  185. },
  186.  
  187. set visibleView(x)
  188. {
  189. if (this._visibleView === x)
  190. return;
  191.  
  192. if (this._visibleView)
  193. this._visibleView.detach();
  194.  
  195. this._visibleView = x;
  196.  
  197. if (x)
  198. x.show(this.viewsContainerElement);
  199. },
  200.  
  201. wasShown: function()
  202. {
  203. WebInspector.Panel.prototype.wasShown.call(this);
  204. if (!this._visibleView)
  205. this.auditsItemTreeElement.select();
  206. },
  207.  
  208. _clearButtonClicked: function()
  209. {
  210. this.auditsItemTreeElement.revealAndSelect();
  211. this.auditResultsTreeElement.removeChildren();
  212. },
  213.  
  214. __proto__: WebInspector.Panel.prototype
  215. }
  216.  
  217.  
  218. WebInspector.AuditCategory = function(displayName)
  219. {
  220. this._displayName = displayName;
  221. this._rules = [];
  222. }
  223.  
  224. WebInspector.AuditCategory.prototype = {
  225.  
  226. get id()
  227. {
  228.  
  229. return this._id;
  230. },
  231.  
  232.  
  233. get displayName()
  234. {
  235. return this._displayName;
  236. },
  237.  
  238.  
  239. addRule: function(rule, severity)
  240. {
  241. rule.severity = severity;
  242. this._rules.push(rule);
  243. },
  244.  
  245.  
  246. run: function(requests, ruleResultCallback, categoryDoneCallback, progress)
  247. {
  248. this._ensureInitialized();
  249. var remainingRulesCount = this._rules.length;
  250. progress.setTotalWork(remainingRulesCount);
  251. function callbackWrapper(result)
  252. {
  253. ruleResultCallback(result);
  254. progress.worked();
  255. if (!--remainingRulesCount)
  256. categoryDoneCallback();
  257. }
  258. for (var i = 0; i < this._rules.length; ++i)
  259. this._rules[i].run(requests, callbackWrapper, progress);
  260. },
  261.  
  262. _ensureInitialized: function()
  263. {
  264. if (!this._initialized) {
  265. if ("initialize" in this)
  266. this.initialize();
  267. this._initialized = true;
  268. }
  269. }
  270. }
  271.  
  272.  
  273. WebInspector.AuditRule = function(id, displayName)
  274. {
  275. this._id = id;
  276. this._displayName = displayName;
  277. }
  278.  
  279.  
  280. WebInspector.AuditRule.Severity = {
  281. Info: "info",
  282. Warning: "warning",
  283. Severe: "severe"
  284. }
  285.  
  286.  
  287. WebInspector.AuditRule.SeverityOrder = {
  288. "info": 3,
  289. "warning": 2,
  290. "severe": 1
  291. }
  292.  
  293. WebInspector.AuditRule.prototype = {
  294. get id()
  295. {
  296. return this._id;
  297. },
  298.  
  299. get displayName()
  300. {
  301. return this._displayName;
  302. },
  303.  
  304.  
  305. set severity(severity)
  306. {
  307. this._severity = severity;
  308. },
  309.  
  310.  
  311. run: function(requests, callback, progress)
  312. {
  313. if (progress.isCanceled())
  314. return;
  315.  
  316. var result = new WebInspector.AuditRuleResult(this.displayName);
  317. result.severity = this._severity;
  318. this.doRun(requests, result, callback, progress);
  319. },
  320.  
  321.  
  322. doRun: function(requests, result, callback, progress)
  323. {
  324. throw new Error("doRun() not implemented");
  325. }
  326. }
  327.  
  328.  
  329. WebInspector.AuditCategoryResult = function(category)
  330. {
  331. this.title = category.displayName;
  332. this.ruleResults = [];
  333. }
  334.  
  335. WebInspector.AuditCategoryResult.prototype = {
  336.  
  337. addRuleResult: function(ruleResult)
  338. {
  339. this.ruleResults.push(ruleResult);
  340. }
  341. }
  342.  
  343.  
  344. WebInspector.AuditRuleResult = function(value, expanded, className)
  345. {
  346. this.value = value;
  347. this.className = className;
  348. this.expanded = expanded;
  349. this.violationCount = 0;
  350. this._formatters = {
  351. r: WebInspector.AuditRuleResult.linkifyDisplayName
  352. };
  353. var standardFormatters = Object.keys(String.standardFormatters);
  354. for (var i = 0; i < standardFormatters.length; ++i)
  355. this._formatters[standardFormatters[i]] = String.standardFormatters[standardFormatters[i]];
  356. }
  357.  
  358.  
  359. WebInspector.AuditRuleResult.linkifyDisplayName = function(url)
  360. {
  361. return WebInspector.linkifyURLAsNode(url, WebInspector.displayNameForURL(url));
  362. }
  363.  
  364. WebInspector.AuditRuleResult.resourceDomain = function(domain)
  365. {
  366. return domain || WebInspector.UIString("[empty domain]");
  367. }
  368.  
  369. WebInspector.AuditRuleResult.prototype = {
  370.  
  371. addChild: function(value, expanded, className)
  372. {
  373. if (!this.children)
  374. this.children = [];
  375. var entry = new WebInspector.AuditRuleResult(value, expanded, className);
  376. this.children.push(entry);
  377. return entry;
  378. },
  379.  
  380.  
  381. addURL: function(url)
  382. {
  383. this.addChild(WebInspector.AuditRuleResult.linkifyDisplayName(url));
  384. },
  385.  
  386.  
  387. addURLs: function(urls)
  388. {
  389. for (var i = 0; i < urls.length; ++i)
  390. this.addURL(urls[i]);
  391. },
  392.  
  393.  
  394. addSnippet: function(snippet)
  395. {
  396. this.addChild(snippet, false, "source-code");
  397. },
  398.  
  399.  
  400. addFormatted: function(format, vararg)
  401. {
  402. var substitutions = Array.prototype.slice.call(arguments, 1);
  403. var fragment = document.createDocumentFragment();
  404.  
  405. function append(a, b)
  406. {
  407. if (!(b instanceof Node))
  408. b = document.createTextNode(b);
  409. a.appendChild(b);
  410. return a;
  411. }
  412.  
  413. var formattedResult = String.format(format, substitutions, this._formatters, fragment, append).formattedResult;
  414. if (formattedResult instanceof Node)
  415. formattedResult.normalize();
  416. return this.addChild(formattedResult);
  417. }
  418. }
  419.  
  420.  
  421. WebInspector.AuditsSidebarTreeElement = function(panel)
  422. {
  423. this._panel = panel;
  424. this.small = false;
  425. WebInspector.SidebarTreeElement.call(this, "audits-sidebar-tree-item", WebInspector.UIString("Audits"), "", null, false);
  426. }
  427.  
  428. WebInspector.AuditsSidebarTreeElement.prototype = {
  429. onattach: function()
  430. {
  431. WebInspector.SidebarTreeElement.prototype.onattach.call(this);
  432. },
  433.  
  434. onselect: function()
  435. {
  436. this._panel.showLauncherView();
  437. },
  438.  
  439. get selectable()
  440. {
  441. return true;
  442. },
  443.  
  444. refresh: function()
  445. {
  446. this.refreshTitles();
  447. },
  448.  
  449. __proto__: WebInspector.SidebarTreeElement.prototype
  450. }
  451.  
  452.  
  453. WebInspector.AuditResultSidebarTreeElement = function(panel, results, mainResourceURL, ordinal)
  454. {
  455. this._panel = panel;
  456. this.results = results;
  457. this.mainResourceURL = mainResourceURL;
  458. WebInspector.SidebarTreeElement.call(this, "audit-result-sidebar-tree-item", String.sprintf("%s (%d)", mainResourceURL, ordinal), "", {}, false);
  459. }
  460.  
  461. WebInspector.AuditResultSidebarTreeElement.prototype = {
  462. onselect: function()
  463. {
  464. this._panel.showResults(this.results);
  465. },
  466.  
  467. get selectable()
  468. {
  469. return true;
  470. },
  471.  
  472. __proto__: WebInspector.SidebarTreeElement.prototype
  473. }
  474.  
  475.  
  476. WebInspector.AuditRules = {};
  477.  
  478.  
  479. WebInspector.AuditCategories = {};
  480.  
  481.  
  482.  
  483.  
  484. WebInspector.AuditCategories.PagePerformance = function() {
  485. WebInspector.AuditCategory.call(this, WebInspector.AuditCategories.PagePerformance.AuditCategoryName);
  486. }
  487.  
  488. WebInspector.AuditCategories.PagePerformance.AuditCategoryName = "Web Page Performance";
  489.  
  490. WebInspector.AuditCategories.PagePerformance.prototype = {
  491. initialize: function()
  492. {
  493. this.addRule(new WebInspector.AuditRules.UnusedCssRule(), WebInspector.AuditRule.Severity.Warning);
  494. this.addRule(new WebInspector.AuditRules.CssInHeadRule(), WebInspector.AuditRule.Severity.Severe);
  495. this.addRule(new WebInspector.AuditRules.StylesScriptsOrderRule(), WebInspector.AuditRule.Severity.Severe);
  496. this.addRule(new WebInspector.AuditRules.VendorPrefixedCSSProperties(), WebInspector.AuditRule.Severity.Warning);
  497. },
  498.  
  499. __proto__: WebInspector.AuditCategory.prototype
  500. }
  501.  
  502.  
  503. WebInspector.AuditCategories.NetworkUtilization = function() {
  504. WebInspector.AuditCategory.call(this, WebInspector.AuditCategories.NetworkUtilization.AuditCategoryName);
  505. }
  506.  
  507. WebInspector.AuditCategories.NetworkUtilization.AuditCategoryName = "Network Utilization";
  508.  
  509. WebInspector.AuditCategories.NetworkUtilization.prototype = {
  510. initialize: function()
  511. {
  512. this.addRule(new WebInspector.AuditRules.GzipRule(), WebInspector.AuditRule.Severity.Severe);
  513. this.addRule(new WebInspector.AuditRules.ImageDimensionsRule(), WebInspector.AuditRule.Severity.Warning);
  514. this.addRule(new WebInspector.AuditRules.CookieSizeRule(400), WebInspector.AuditRule.Severity.Warning);
  515. this.addRule(new WebInspector.AuditRules.StaticCookielessRule(5), WebInspector.AuditRule.Severity.Warning);
  516. this.addRule(new WebInspector.AuditRules.CombineJsResourcesRule(2), WebInspector.AuditRule.Severity.Severe);
  517. this.addRule(new WebInspector.AuditRules.CombineCssResourcesRule(2), WebInspector.AuditRule.Severity.Severe);
  518. this.addRule(new WebInspector.AuditRules.MinimizeDnsLookupsRule(4), WebInspector.AuditRule.Severity.Warning);
  519. this.addRule(new WebInspector.AuditRules.ParallelizeDownloadRule(4, 10, 0.5), WebInspector.AuditRule.Severity.Warning);
  520. this.addRule(new WebInspector.AuditRules.BrowserCacheControlRule(), WebInspector.AuditRule.Severity.Severe);
  521. this.addRule(new WebInspector.AuditRules.ProxyCacheControlRule(), WebInspector.AuditRule.Severity.Warning);
  522. },
  523.  
  524. __proto__: WebInspector.AuditCategory.prototype
  525. }
  526. ;
  527.  
  528.  
  529.  
  530. WebInspector.AuditFormatters = function()
  531. {
  532. }
  533.  
  534. WebInspector.AuditFormatters.Registry = {
  535. text: function(text)
  536. {
  537. return document.createTextNode(text);
  538. },
  539.  
  540. snippet: function(snippetText)
  541. {
  542. var div = document.createElement("div");
  543. div.textContent = snippetText;
  544. div.className = "source-code";
  545. return div;
  546. },
  547.  
  548. concat: function()
  549. {
  550. var parent = document.createElement("span");
  551. for (var arg = 0; arg < arguments.length; ++arg)
  552. parent.appendChild(WebInspector.auditFormatters.apply(arguments[arg]));
  553. return parent;
  554. },
  555.  
  556. url: function(url, displayText, allowExternalNavigation)
  557. {
  558. var a = document.createElement("a");
  559. a.href = sanitizeHref(url);
  560. a.title = url;
  561. a.textContent = displayText || url;
  562. if (allowExternalNavigation)
  563. a.target = "_blank";
  564. return a;
  565. },
  566.  
  567. resourceLink: function(url, line)
  568. {
  569.  
  570. return WebInspector.linkifyResourceAsNode(url, line, "console-message-url webkit-html-resource-link");
  571. }
  572. };
  573.  
  574. WebInspector.AuditFormatters.prototype = {
  575.  
  576. apply: function(value)
  577. {
  578. var formatter;
  579. var type = typeof value;
  580. var args;
  581.  
  582. switch (type) {
  583. case "string":
  584. case "boolean":
  585. case "number":
  586. formatter = WebInspector.AuditFormatters.Registry.text;
  587. args = [ value.toString() ];
  588. break;
  589.  
  590. case "object":
  591. if (value instanceof Node)
  592. return value;
  593. if (value instanceof Array) {
  594. formatter = WebInspector.AuditFormatters.Registry.concat;
  595. args = value;
  596. } else if (value.type && value.arguments) {
  597. formatter = WebInspector.AuditFormatters.Registry[value.type];
  598. args = value.arguments;
  599. }
  600. }
  601. if (!formatter)
  602. throw "Invalid value or formatter: " + type + JSON.stringify(value);
  603.  
  604. return formatter.apply(null, args);
  605. },
  606.  
  607.  
  608. partiallyApply: function(formatters, thisArgument, value)
  609. {
  610. if (value instanceof Array)
  611. return value.map(this.partiallyApply.bind(this, formatters, thisArgument));
  612. if (typeof value === "object" && typeof formatters[value.type] === "function" && value.arguments)
  613. return formatters[value.type].apply(thisArgument, value.arguments);
  614. return value;
  615. }
  616. }
  617.  
  618. WebInspector.auditFormatters = new WebInspector.AuditFormatters();
  619. ;
  620.  
  621.  
  622.  
  623. WebInspector.AuditLauncherView = function(runnerCallback)
  624. {
  625. WebInspector.View.call(this);
  626.  
  627. this._runnerCallback = runnerCallback;
  628. this._categoryIdPrefix = "audit-category-item-";
  629. this._auditRunning = false;
  630.  
  631. this.element.addStyleClass("audit-launcher-view");
  632. this.element.addStyleClass("panel-enabler-view");
  633.  
  634. this._contentElement = document.createElement("div");
  635. this._contentElement.className = "audit-launcher-view-content";
  636. this.element.appendChild(this._contentElement);
  637. this._boundCategoryClickListener = this._categoryClicked.bind(this);
  638.  
  639. this._resetResourceCount();
  640.  
  641. this._sortedCategories = [];
  642.  
  643. this._headerElement = document.createElement("h1");
  644. this._headerElement.className = "no-audits";
  645. this._headerElement.textContent = WebInspector.UIString("No audits to run");
  646. this._contentElement.appendChild(this._headerElement);
  647.  
  648. WebInspector.networkManager.addEventListener(WebInspector.NetworkManager.EventTypes.RequestStarted, this._onRequestStarted, this);
  649. WebInspector.networkManager.addEventListener(WebInspector.NetworkManager.EventTypes.RequestFinished, this._onRequestFinished, this);
  650.  
  651. var defaultSelectedAuditCategory = {};
  652. defaultSelectedAuditCategory[WebInspector.AuditLauncherView.AllCategoriesKey] = true;
  653. this._selectedCategoriesSetting = WebInspector.settings.createSetting("selectedAuditCategories", defaultSelectedAuditCategory);
  654. }
  655.  
  656. WebInspector.AuditLauncherView.AllCategoriesKey = "__AllCategories";
  657.  
  658. WebInspector.AuditLauncherView.prototype = {
  659. _resetResourceCount: function()
  660. {
  661. this._loadedResources = 0;
  662. this._totalResources = 0;
  663. },
  664.  
  665. _onRequestStarted: function(event)
  666. {
  667. var request =   (event.data);
  668.  
  669. if (request.type === WebInspector.resourceTypes.WebSocket)
  670. return;
  671. ++this._totalResources;
  672. this._updateResourceProgress();
  673. },
  674.  
  675. _onRequestFinished: function(event)
  676. {
  677. var request =   (event.data);
  678.  
  679. if (request.type === WebInspector.resourceTypes.WebSocket)
  680. return;
  681. ++this._loadedResources;
  682. this._updateResourceProgress();
  683. },
  684.  
  685.  
  686. addCategory: function(category)
  687. {
  688. if (!this._sortedCategories.length)
  689. this._createLauncherUI();
  690.  
  691. var selectedCategories = this._selectedCategoriesSetting.get();
  692. var categoryElement = this._createCategoryElement(category.displayName, category.id);
  693. category._checkboxElement = categoryElement.firstChild;
  694. if (this._selectAllCheckboxElement.checked || selectedCategories[category.displayName]) {
  695. category._checkboxElement.checked = true;
  696. ++this._currentCategoriesCount;
  697. }
  698.  
  699. function compareCategories(a, b)
  700. {
  701. var aTitle = a.displayName || "";
  702. var bTitle = b.displayName || "";
  703. return aTitle.localeCompare(bTitle);
  704. }
  705. var insertBefore = insertionIndexForObjectInListSortedByFunction(category, this._sortedCategories, compareCategories);
  706. this._categoriesElement.insertBefore(categoryElement, this._categoriesElement.children[insertBefore]);
  707. this._sortedCategories.splice(insertBefore, 0, category);
  708. this._selectedCategoriesUpdated();
  709. },
  710.  
  711.  
  712. _setAuditRunning: function(auditRunning)
  713. {
  714. if (this._auditRunning === auditRunning)
  715. return;
  716. this._auditRunning = auditRunning;
  717. this._updateButton();
  718. if (this._auditRunning)
  719. this._startAudit();
  720. else
  721. this._stopAudit();
  722. },
  723.  
  724. _startAudit: function()
  725. {
  726. var catIds = [];
  727. for (var category = 0; category < this._sortedCategories.length; ++category) {
  728. if (this._sortedCategories[category]._checkboxElement.checked)
  729. catIds.push(this._sortedCategories[category].id);
  730. }
  731.  
  732. this._resetResourceCount();
  733. this._progressIndicator = new WebInspector.ProgressIndicator();
  734. this._buttonContainerElement.appendChild(this._progressIndicator.element);
  735. this._displayResourceLoadingProgress = true;
  736.  
  737. function onAuditStarted()
  738. {
  739. this._displayResourceLoadingProgress = false;
  740. }
  741. this._runnerCallback(catIds, this._progressIndicator, this._auditPresentStateElement.checked, onAuditStarted.bind(this), this._setAuditRunning.bind(this, false));
  742. },
  743.  
  744. _stopAudit: function()
  745. {
  746. this._displayResourceLoadingProgress = false;
  747. this._progressIndicator.cancel();
  748. this._progressIndicator.done();
  749. delete this._progressIndicator;
  750. },
  751.  
  752. _launchButtonClicked: function(event)
  753. {
  754. this._setAuditRunning(!this._auditRunning);
  755. },
  756.  
  757.  
  758. _selectAllClicked: function(checkCategories, userGesture)
  759. {
  760. var childNodes = this._categoriesElement.childNodes;
  761. for (var i = 0, length = childNodes.length; i < length; ++i)
  762. childNodes[i].firstChild.checked = checkCategories;
  763. this._currentCategoriesCount = checkCategories ? this._sortedCategories.length : 0;
  764. this._selectedCategoriesUpdated(userGesture);
  765. },
  766.  
  767. _categoryClicked: function(event)
  768. {
  769. this._currentCategoriesCount += event.target.checked ? 1 : -1;
  770. this._selectAllCheckboxElement.checked = this._currentCategoriesCount === this._sortedCategories.length;
  771. this._selectedCategoriesUpdated(true);
  772. },
  773.  
  774.  
  775. _createCategoryElement: function(title, id)
  776. {
  777. var labelElement = document.createElement("label");
  778. labelElement.id = this._categoryIdPrefix + id;
  779.  
  780. var element = document.createElement("input");
  781. element.type = "checkbox";
  782. if (id !== "")
  783. element.addEventListener("click", this._boundCategoryClickListener, false);
  784. labelElement.appendChild(element);
  785. labelElement.appendChild(document.createTextNode(title));
  786. labelElement.__displayName = title;
  787.  
  788. return labelElement;
  789. },
  790.  
  791. _createLauncherUI: function()
  792. {
  793. this._headerElement = document.createElement("h1");
  794. this._headerElement.textContent = WebInspector.UIString("Select audits to run");
  795.  
  796. for (var child = 0; child < this._contentElement.children.length; ++child)
  797. this._contentElement.removeChild(this._contentElement.children[child]);
  798.  
  799. this._contentElement.appendChild(this._headerElement);
  800.  
  801. function handleSelectAllClick(event)
  802. {
  803. this._selectAllClicked(event.target.checked, true);
  804. }
  805. var categoryElement = this._createCategoryElement(WebInspector.UIString("Select All"), "");
  806. categoryElement.id = "audit-launcher-selectall";
  807. this._selectAllCheckboxElement = categoryElement.firstChild;
  808. this._selectAllCheckboxElement.checked = this._selectedCategoriesSetting.get()[WebInspector.AuditLauncherView.AllCategoriesKey];
  809. this._selectAllCheckboxElement.addEventListener("click", handleSelectAllClick.bind(this), false);
  810. this._contentElement.appendChild(categoryElement);
  811.  
  812. this._categoriesElement = this._contentElement.createChild("div", "audit-categories-container");
  813. this._currentCategoriesCount = 0;
  814.  
  815. this._contentElement.createChild("div", "flexible-space");
  816.  
  817. this._buttonContainerElement = this._contentElement.createChild("div", "button-container");
  818.  
  819. var labelElement = this._buttonContainerElement.createChild("label");
  820. this._auditPresentStateElement = labelElement.createChild("input");
  821. this._auditPresentStateElement.name = "audit-mode";
  822. this._auditPresentStateElement.type = "radio";
  823. this._auditPresentStateElement.checked = true;
  824. this._auditPresentStateLabelElement = document.createTextNode(WebInspector.UIString("Audit Present State"));
  825. labelElement.appendChild(this._auditPresentStateLabelElement);
  826.  
  827. labelElement = this._buttonContainerElement.createChild("label");
  828. this.auditReloadedStateElement = labelElement.createChild("input");
  829. this.auditReloadedStateElement.name = "audit-mode";
  830. this.auditReloadedStateElement.type = "radio";
  831. labelElement.appendChild(document.createTextNode("Reload Page and Audit on Load"));
  832.  
  833. this._launchButton = this._buttonContainerElement.createChild("button");
  834. this._launchButton.textContent = WebInspector.UIString("Run");
  835. this._launchButton.addEventListener("click", this._launchButtonClicked.bind(this), false);
  836.  
  837. this._selectAllClicked(this._selectAllCheckboxElement.checked);
  838. },
  839.  
  840. _updateResourceProgress: function()
  841. {
  842. if (this._displayResourceLoadingProgress)
  843. this._progressIndicator.setTitle(WebInspector.UIString("Loading (%d of %d)", this._loadedResources, this._totalResources));
  844. },
  845.  
  846.  
  847. _selectedCategoriesUpdated: function(userGesture)
  848. {
  849.  
  850.  
  851.  
  852. var selectedCategories = userGesture ? {} : this._selectedCategoriesSetting.get();
  853. var childNodes = this._categoriesElement.childNodes;
  854. for (var i = 0, length = childNodes.length; i < length; ++i)
  855. selectedCategories[childNodes[i].__displayName] = childNodes[i].firstChild.checked;
  856. selectedCategories[WebInspector.AuditLauncherView.AllCategoriesKey] = this._selectAllCheckboxElement.checked;
  857. this._selectedCategoriesSetting.set(selectedCategories);
  858. this._updateButton();
  859. },
  860.  
  861. _updateButton: function()
  862. {
  863. this._launchButton.textContent = this._auditRunning ? WebInspector.UIString("Stop") : WebInspector.UIString("Run");
  864. this._launchButton.disabled = !this._currentCategoriesCount;
  865. },
  866.  
  867. __proto__: WebInspector.View.prototype
  868. }
  869. ;
  870.  
  871.  
  872.  
  873. WebInspector.AuditResultView = function(categoryResults)
  874. {
  875. WebInspector.View.call(this);
  876. this.element.className = "audit-result-view";
  877.  
  878. function categorySorter(a, b) {
  879. return (a.title || "").localeCompare(b.title || "");
  880. }
  881. categoryResults.sort(categorySorter);
  882. for (var i = 0; i < categoryResults.length; ++i)
  883. this.element.appendChild(new WebInspector.AuditCategoryResultPane(categoryResults[i]).element);
  884. }
  885.  
  886. WebInspector.AuditResultView.prototype = {
  887. __proto__: WebInspector.View.prototype
  888. }
  889.  
  890.  
  891. WebInspector.AuditCategoryResultPane = function(categoryResult)
  892. {
  893. WebInspector.SidebarPane.call(this, categoryResult.title);
  894. var treeOutlineElement = document.createElement("ol");
  895. this.bodyElement.addStyleClass("audit-result-tree");
  896. this.bodyElement.appendChild(treeOutlineElement);
  897.  
  898. this._treeOutline = new TreeOutline(treeOutlineElement);
  899. this._treeOutline.expandTreeElementsWhenArrowing = true;
  900.  
  901. function ruleSorter(a, b)
  902. {
  903. var result = WebInspector.AuditRule.SeverityOrder[a.severity || 0] - WebInspector.AuditRule.SeverityOrder[b.severity || 0];
  904. if (!result)
  905. result = (a.value || "").localeCompare(b.value || "");
  906. return result;
  907. }
  908.  
  909. categoryResult.ruleResults.sort(ruleSorter);
  910.  
  911. for (var i = 0; i < categoryResult.ruleResults.length; ++i) {
  912. var ruleResult = categoryResult.ruleResults[i];
  913. var treeElement = this._appendResult(this._treeOutline, ruleResult);
  914. treeElement.listItemElement.addStyleClass("audit-result");
  915.  
  916. if (ruleResult.severity) {
  917. var severityElement = document.createElement("img");
  918. severityElement.className = "severity-" + ruleResult.severity;
  919. treeElement.listItemElement.appendChild(severityElement);
  920. }
  921. }
  922. this.expand();
  923. }
  924.  
  925. WebInspector.AuditCategoryResultPane.prototype = {
  926.  
  927. _appendResult: function(parentTreeElement, result)
  928. {
  929. var title = "";
  930.  
  931. if (typeof result.value === "string") {
  932. title = result.value;
  933. if (result.violationCount)
  934. title = String.sprintf("%s (%d)", title, result.violationCount);
  935. }
  936.  
  937. var treeElement = new TreeElement(null, null, !!result.children);
  938. treeElement.title = title;
  939. parentTreeElement.appendChild(treeElement);
  940.  
  941. if (result.className)
  942. treeElement.listItemElement.addStyleClass(result.className);
  943. if (typeof result.value !== "string")
  944. treeElement.listItemElement.appendChild(WebInspector.auditFormatters.apply(result.value));
  945.  
  946. if (result.children) {
  947. for (var i = 0; i < result.children.length; ++i)
  948. this._appendResult(treeElement, result.children[i]);
  949. }
  950. if (result.expanded) {
  951. treeElement.listItemElement.removeStyleClass("parent");
  952. treeElement.listItemElement.addStyleClass("parent-expanded");
  953. treeElement.expand();
  954. }
  955. return treeElement;
  956. },
  957.  
  958. __proto__: WebInspector.SidebarPane.prototype
  959. }
  960. ;
  961.  
  962.  
  963. WebInspector.AuditRules.IPAddressRegexp = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
  964.  
  965. WebInspector.AuditRules.CacheableResponseCodes =
  966. {
  967. 200: true,
  968. 203: true,
  969. 206: true,
  970. 300: true,
  971. 301: true,
  972. 410: true,
  973.  
  974. 304: true 
  975. }
  976.  
  977.  
  978. WebInspector.AuditRules.getDomainToResourcesMap = function(requests, types, needFullResources)
  979. {
  980. var domainToResourcesMap = {};
  981. for (var i = 0, size = requests.length; i < size; ++i) {
  982. var request = requests[i];
  983. if (types && types.indexOf(request.type) === -1)
  984. continue;
  985. var parsedURL = request.url.asParsedURL();
  986. if (!parsedURL)
  987. continue;
  988. var domain = parsedURL.host;
  989. var domainResources = domainToResourcesMap[domain];
  990. if (domainResources === undefined) {
  991. domainResources = [];
  992. domainToResourcesMap[domain] = domainResources;
  993. }
  994. domainResources.push(needFullResources ? request : request.url);
  995. }
  996. return domainToResourcesMap;
  997. }
  998.  
  999.  
  1000. WebInspector.AuditRules.GzipRule = function()
  1001. {
  1002. WebInspector.AuditRule.call(this, "network-gzip", "Enable gzip compression");
  1003. }
  1004.  
  1005. WebInspector.AuditRules.GzipRule.prototype = {
  1006.  
  1007. doRun: function(requests, result, callback, progress)
  1008. {
  1009. var totalSavings = 0;
  1010. var compressedSize = 0;
  1011. var candidateSize = 0;
  1012. var summary = result.addChild("", true);
  1013. for (var i = 0, length = requests.length; i < length; ++i) {
  1014. var request = requests[i];
  1015. if (request.statusCode === 304)
  1016. continue; 
  1017. if (this._shouldCompress(request)) {
  1018. var size = request.resourceSize;
  1019. candidateSize += size;
  1020. if (this._isCompressed(request)) {
  1021. compressedSize += size;
  1022. continue;
  1023. }
  1024. var savings = 2 * size / 3;
  1025. totalSavings += savings;
  1026. summary.addFormatted("%r could save ~%s", request.url, Number.bytesToString(savings));
  1027. result.violationCount++;
  1028. }
  1029. }
  1030. if (!totalSavings)
  1031. return callback(null);
  1032. summary.value = String.sprintf("Compressing the following resources with gzip could reduce their transfer size by about two thirds (~%s):", Number.bytesToString(totalSavings));
  1033. callback(result);
  1034. },
  1035.  
  1036. _isCompressed: function(request)
  1037. {
  1038. var encodingHeader = request.responseHeaderValue("Content-Encoding");
  1039. if (!encodingHeader)
  1040. return false;
  1041.  
  1042. return /\b(?:gzip|deflate)\b/.test(encodingHeader);
  1043. },
  1044.  
  1045. _shouldCompress: function(request)
  1046. {
  1047. return request.type.isTextType() && request.parsedURL.host && request.resourceSize !== undefined && request.resourceSize > 150;
  1048. },
  1049.  
  1050. __proto__: WebInspector.AuditRule.prototype
  1051. }
  1052.  
  1053.  
  1054. WebInspector.AuditRules.CombineExternalResourcesRule = function(id, name, type, resourceTypeName, allowedPerDomain)
  1055. {
  1056. WebInspector.AuditRule.call(this, id, name);
  1057. this._type = type;
  1058. this._resourceTypeName = resourceTypeName;
  1059. this._allowedPerDomain = allowedPerDomain;
  1060. }
  1061.  
  1062. WebInspector.AuditRules.CombineExternalResourcesRule.prototype = {
  1063.  
  1064. doRun: function(requests, result, callback, progress)
  1065. {
  1066. var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(requests, [this._type], false);
  1067. var penalizedResourceCount = 0;
  1068.  
  1069. var summary = result.addChild("", true);
  1070. for (var domain in domainToResourcesMap) {
  1071. var domainResources = domainToResourcesMap[domain];
  1072. var extraResourceCount = domainResources.length - this._allowedPerDomain;
  1073. if (extraResourceCount <= 0)
  1074. continue;
  1075. penalizedResourceCount += extraResourceCount - 1;
  1076. summary.addChild(String.sprintf("%d %s resources served from %s.", domainResources.length, this._resourceTypeName, WebInspector.AuditRuleResult.resourceDomain(domain)));
  1077. result.violationCount += domainResources.length;
  1078. }
  1079. if (!penalizedResourceCount)
  1080. return callback(null);
  1081.  
  1082. summary.value = "There are multiple resources served from same domain. Consider combining them into as few files as possible.";
  1083. callback(result);
  1084. },
  1085.  
  1086. __proto__: WebInspector.AuditRule.prototype
  1087. }
  1088.  
  1089.  
  1090. WebInspector.AuditRules.CombineJsResourcesRule = function(allowedPerDomain) {
  1091. WebInspector.AuditRules.CombineExternalResourcesRule.call(this, "page-externaljs", "Combine external JavaScript", WebInspector.resourceTypes.Script, "JavaScript", allowedPerDomain);
  1092. }
  1093.  
  1094. WebInspector.AuditRules.CombineJsResourcesRule.prototype = {
  1095. __proto__: WebInspector.AuditRules.CombineExternalResourcesRule.prototype
  1096. }
  1097.  
  1098.  
  1099. WebInspector.AuditRules.CombineCssResourcesRule = function(allowedPerDomain) {
  1100. WebInspector.AuditRules.CombineExternalResourcesRule.call(this, "page-externalcss", "Combine external CSS", WebInspector.resourceTypes.Stylesheet, "CSS", allowedPerDomain);
  1101. }
  1102.  
  1103. WebInspector.AuditRules.CombineCssResourcesRule.prototype = {
  1104. __proto__: WebInspector.AuditRules.CombineExternalResourcesRule.prototype
  1105. }
  1106.  
  1107.  
  1108. WebInspector.AuditRules.MinimizeDnsLookupsRule = function(hostCountThreshold) {
  1109. WebInspector.AuditRule.call(this, "network-minimizelookups", "Minimize DNS lookups");
  1110. this._hostCountThreshold = hostCountThreshold;
  1111. }
  1112.  
  1113. WebInspector.AuditRules.MinimizeDnsLookupsRule.prototype = {
  1114.  
  1115. doRun: function(requests, result, callback, progress)
  1116. {
  1117. var summary = result.addChild("");
  1118. var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(requests, null, false);
  1119. for (var domain in domainToResourcesMap) {
  1120. if (domainToResourcesMap[domain].length > 1)
  1121. continue;
  1122. var parsedURL = domain.asParsedURL();
  1123. if (!parsedURL)
  1124. continue;
  1125. if (!parsedURL.host.search(WebInspector.AuditRules.IPAddressRegexp))
  1126. continue; 
  1127. summary.addSnippet(domain);
  1128. result.violationCount++;
  1129. }
  1130. if (!summary.children || summary.children.length <= this._hostCountThreshold)
  1131. return callback(null);
  1132.  
  1133. summary.value = "The following domains only serve one resource each. If possible, avoid the extra DNS lookups by serving these resources from existing domains.";
  1134. callback(result);
  1135. },
  1136.  
  1137. __proto__: WebInspector.AuditRule.prototype
  1138. }
  1139.  
  1140.  
  1141. WebInspector.AuditRules.ParallelizeDownloadRule = function(optimalHostnameCount, minRequestThreshold, minBalanceThreshold)
  1142. {
  1143. WebInspector.AuditRule.call(this, "network-parallelizehosts", "Parallelize downloads across hostnames");
  1144. this._optimalHostnameCount = optimalHostnameCount;
  1145. this._minRequestThreshold = minRequestThreshold;
  1146. this._minBalanceThreshold = minBalanceThreshold;
  1147. }
  1148.  
  1149. WebInspector.AuditRules.ParallelizeDownloadRule.prototype = {
  1150.  
  1151. doRun: function(requests, result, callback, progress)
  1152. {
  1153. function hostSorter(a, b)
  1154. {
  1155. var aCount = domainToResourcesMap[a].length;
  1156. var bCount = domainToResourcesMap[b].length;
  1157. return (aCount < bCount) ? 1 : (aCount == bCount) ? 0 : -1;
  1158. }
  1159.  
  1160. var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(
  1161. requests,
  1162. [WebInspector.resourceTypes.Stylesheet, WebInspector.resourceTypes.Image],
  1163. true);
  1164.  
  1165. var hosts = [];
  1166. for (var url in domainToResourcesMap)
  1167. hosts.push(url);
  1168.  
  1169. if (!hosts.length)
  1170. return callback(null); 
  1171.  
  1172. hosts.sort(hostSorter);
  1173.  
  1174. var optimalHostnameCount = this._optimalHostnameCount;
  1175. if (hosts.length > optimalHostnameCount)
  1176. hosts.splice(optimalHostnameCount);
  1177.  
  1178. var busiestHostResourceCount = domainToResourcesMap[hosts[0]].length;
  1179. var requestCountAboveThreshold = busiestHostResourceCount - this._minRequestThreshold;
  1180. if (requestCountAboveThreshold <= 0)
  1181. return callback(null);
  1182.  
  1183. var avgResourcesPerHost = 0;
  1184. for (var i = 0, size = hosts.length; i < size; ++i)
  1185. avgResourcesPerHost += domainToResourcesMap[hosts[i]].length;
  1186.  
  1187.  
  1188. avgResourcesPerHost /= optimalHostnameCount;
  1189. avgResourcesPerHost = Math.max(avgResourcesPerHost, 1);
  1190.  
  1191. var pctAboveAvg = (requestCountAboveThreshold / avgResourcesPerHost) - 1.0;
  1192. var minBalanceThreshold = this._minBalanceThreshold;
  1193. if (pctAboveAvg < minBalanceThreshold)
  1194. return callback(null);
  1195.  
  1196. var requestsOnBusiestHost = domainToResourcesMap[hosts[0]];
  1197. var entry = result.addChild(String.sprintf("This page makes %d parallelizable requests to %s. Increase download parallelization by distributing the following requests across multiple hostnames.", busiestHostResourceCount, hosts[0]), true);
  1198. for (var i = 0; i < requestsOnBusiestHost.length; ++i)
  1199. entry.addURL(requestsOnBusiestHost[i].url);
  1200.  
  1201. result.violationCount = requestsOnBusiestHost.length;
  1202. callback(result);
  1203. },
  1204.  
  1205. __proto__: WebInspector.AuditRule.prototype
  1206. }
  1207.  
  1208.  
  1209. WebInspector.AuditRules.UnusedCssRule = function()
  1210. {
  1211. WebInspector.AuditRule.call(this, "page-unusedcss", "Remove unused CSS rules");
  1212. }
  1213.  
  1214. WebInspector.AuditRules.UnusedCssRule.prototype = {
  1215.  
  1216. doRun: function(requests, result, callback, progress)
  1217. {
  1218. var self = this;
  1219.  
  1220. function evalCallback(styleSheets) {
  1221. if (progress.isCanceled())
  1222. return;
  1223.  
  1224. if (!styleSheets.length)
  1225. return callback(null);
  1226.  
  1227. var pseudoSelectorRegexp = /:hover|:link|:active|:visited|:focus|:before|:after/;
  1228. var selectors = [];
  1229. var testedSelectors = {};
  1230. for (var i = 0; i < styleSheets.length; ++i) {
  1231. var styleSheet = styleSheets[i];
  1232. for (var curRule = 0; curRule < styleSheet.rules.length; ++curRule) {
  1233. var selectorText = styleSheet.rules[curRule].selectorText;
  1234. if (selectorText.match(pseudoSelectorRegexp) || testedSelectors[selectorText])
  1235. continue;
  1236. selectors.push(selectorText);
  1237. testedSelectors[selectorText] = 1;
  1238. }
  1239. }
  1240.  
  1241. function selectorsCallback(callback, styleSheets, testedSelectors, foundSelectors)
  1242. {
  1243. if (progress.isCanceled())
  1244. return;
  1245.  
  1246. var inlineBlockOrdinal = 0;
  1247. var totalStylesheetSize = 0;
  1248. var totalUnusedStylesheetSize = 0;
  1249. var summary;
  1250.  
  1251. for (var i = 0; i < styleSheets.length; ++i) {
  1252. var styleSheet = styleSheets[i];
  1253. var stylesheetSize = 0;
  1254. var unusedStylesheetSize = 0;
  1255. var unusedRules = [];
  1256. for (var curRule = 0; curRule < styleSheet.rules.length; ++curRule) {
  1257. var rule = styleSheet.rules[curRule];
  1258.  
  1259. var textLength = (rule.selectorRange && rule.style.range && rule.style.range.end) ? rule.style.range.end - rule.selectorRange.start + 1 : 0;
  1260. if (!textLength && rule.style.cssText)
  1261. textLength = rule.style.cssText.length + rule.selectorText.length;
  1262. stylesheetSize += textLength;
  1263. if (!testedSelectors[rule.selectorText] || foundSelectors[rule.selectorText])
  1264. continue;
  1265. unusedStylesheetSize += textLength;
  1266. unusedRules.push(rule.selectorText);
  1267. }
  1268. totalStylesheetSize += stylesheetSize;
  1269. totalUnusedStylesheetSize += unusedStylesheetSize;
  1270.  
  1271. if (!unusedRules.length)
  1272. continue;
  1273.  
  1274. var resource = WebInspector.resourceForURL(styleSheet.sourceURL);
  1275. var isInlineBlock = resource && resource.request && resource.request.type == WebInspector.resourceTypes.Document;
  1276. var url = !isInlineBlock ? WebInspector.AuditRuleResult.linkifyDisplayName(styleSheet.sourceURL) : String.sprintf("Inline block #%d", ++inlineBlockOrdinal);
  1277. var pctUnused = Math.round(100 * unusedStylesheetSize / stylesheetSize);
  1278. if (!summary)
  1279. summary = result.addChild("", true);
  1280. var entry = summary.addFormatted("%s: %s (%d%) is not used by the current page.", url, Number.bytesToString(unusedStylesheetSize), pctUnused);
  1281.  
  1282. for (var j = 0; j < unusedRules.length; ++j)
  1283. entry.addSnippet(unusedRules[j]);
  1284.  
  1285. result.violationCount += unusedRules.length;
  1286. }
  1287.  
  1288. if (!totalUnusedStylesheetSize)
  1289. return callback(null);
  1290.  
  1291. var totalUnusedPercent = Math.round(100 * totalUnusedStylesheetSize / totalStylesheetSize);
  1292. summary.value = String.sprintf("%s (%d%) of CSS is not used by the current page.", Number.bytesToString(totalUnusedStylesheetSize), totalUnusedPercent);
  1293.  
  1294. callback(result);
  1295. }
  1296.  
  1297. var foundSelectors = {};
  1298. function queryCallback(boundSelectorsCallback, selector, styleSheets, testedSelectors, nodeId)
  1299. {
  1300. if (nodeId)
  1301. foundSelectors[selector] = true;
  1302. if (boundSelectorsCallback)
  1303. boundSelectorsCallback(foundSelectors);
  1304. }
  1305.  
  1306. function documentLoaded(selectors, document) {
  1307. for (var i = 0; i < selectors.length; ++i) {
  1308. if (progress.isCanceled())
  1309. return;
  1310. WebInspector.domAgent.querySelector(document.id, selectors[i], queryCallback.bind(null, i === selectors.length - 1 ? selectorsCallback.bind(null, callback, styleSheets, testedSelectors) : null, selectors[i], styleSheets, testedSelectors));
  1311. }
  1312. }
  1313.  
  1314. WebInspector.domAgent.requestDocument(documentLoaded.bind(null, selectors));
  1315. }
  1316.  
  1317. function styleSheetCallback(styleSheets, sourceURL, continuation, styleSheet)
  1318. {
  1319. if (progress.isCanceled())
  1320. return;
  1321.  
  1322. if (styleSheet) {
  1323. styleSheet.sourceURL = sourceURL;
  1324. styleSheets.push(styleSheet);
  1325. }
  1326. if (continuation)
  1327. continuation(styleSheets);
  1328. }
  1329.  
  1330. function allStylesCallback(error, styleSheetInfos)
  1331. {
  1332. if (progress.isCanceled())
  1333. return;
  1334.  
  1335. if (error || !styleSheetInfos || !styleSheetInfos.length)
  1336. return evalCallback([]);
  1337. var styleSheets = [];
  1338. for (var i = 0; i < styleSheetInfos.length; ++i) {
  1339. var info = styleSheetInfos[i];
  1340. WebInspector.CSSStyleSheet.createForId(info.styleSheetId, styleSheetCallback.bind(null, styleSheets, info.sourceURL, i == styleSheetInfos.length - 1 ? evalCallback : null));
  1341. }
  1342. }
  1343.  
  1344. CSSAgent.getAllStyleSheets(allStylesCallback);
  1345. },
  1346.  
  1347. __proto__: WebInspector.AuditRule.prototype
  1348. }
  1349.  
  1350.  
  1351. WebInspector.AuditRules.CacheControlRule = function(id, name)
  1352. {
  1353. WebInspector.AuditRule.call(this, id, name);
  1354. }
  1355.  
  1356. WebInspector.AuditRules.CacheControlRule.MillisPerMonth = 1000 * 60 * 60 * 24 * 30;
  1357.  
  1358. WebInspector.AuditRules.CacheControlRule.prototype = {
  1359.  
  1360. doRun: function(requests, result, callback, progress)
  1361. {
  1362. var cacheableAndNonCacheableResources = this._cacheableAndNonCacheableResources(requests);
  1363. if (cacheableAndNonCacheableResources[0].length)
  1364. this.runChecks(cacheableAndNonCacheableResources[0], result);
  1365. this.handleNonCacheableResources(cacheableAndNonCacheableResources[1], result);
  1366.  
  1367. callback(result);
  1368. },
  1369.  
  1370. handleNonCacheableResources: function(requests, result)
  1371. {
  1372. },
  1373.  
  1374. _cacheableAndNonCacheableResources: function(requests)
  1375. {
  1376. var processedResources = [[], []];
  1377. for (var i = 0; i < requests.length; ++i) {
  1378. var request = requests[i];
  1379. if (!this.isCacheableResource(request))
  1380. continue;
  1381. if (this._isExplicitlyNonCacheable(request))
  1382. processedResources[1].push(request);
  1383. else
  1384. processedResources[0].push(request);
  1385. }
  1386. return processedResources;
  1387. },
  1388.  
  1389. execCheck: function(messageText, requestCheckFunction, requests, result)
  1390. {
  1391. var requestCount = requests.length;
  1392. var urls = [];
  1393. for (var i = 0; i < requestCount; ++i) {
  1394. if (requestCheckFunction.call(this, requests[i]))
  1395. urls.push(requests[i].url);
  1396. }
  1397. if (urls.length) {
  1398. var entry = result.addChild(messageText, true);
  1399. entry.addURLs(urls);
  1400. result.violationCount += urls.length;
  1401. }
  1402. },
  1403.  
  1404. freshnessLifetimeGreaterThan: function(request, timeMs)
  1405. {
  1406. var dateHeader = this.responseHeader(request, "Date");
  1407. if (!dateHeader)
  1408. return false;
  1409.  
  1410. var dateHeaderMs = Date.parse(dateHeader);
  1411. if (isNaN(dateHeaderMs))
  1412. return false;
  1413.  
  1414. var freshnessLifetimeMs;
  1415. var maxAgeMatch = this.responseHeaderMatch(request, "Cache-Control", "max-age=(\\d+)");
  1416.  
  1417. if (maxAgeMatch)
  1418. freshnessLifetimeMs = (maxAgeMatch[1]) ? 1000 * maxAgeMatch[1] : 0;
  1419. else {
  1420. var expiresHeader = this.responseHeader(request, "Expires");
  1421. if (expiresHeader) {
  1422. var expDate = Date.parse(expiresHeader);
  1423. if (!isNaN(expDate))
  1424. freshnessLifetimeMs = expDate - dateHeaderMs;
  1425. }
  1426. }
  1427.  
  1428. return (isNaN(freshnessLifetimeMs)) ? false : freshnessLifetimeMs > timeMs;
  1429. },
  1430.  
  1431. responseHeader: function(request, header)
  1432. {
  1433. return request.responseHeaderValue(header);
  1434. },
  1435.  
  1436. hasResponseHeader: function(request, header)
  1437. {
  1438. return request.responseHeaderValue(header) !== undefined;
  1439. },
  1440.  
  1441. isCompressible: function(request)
  1442. {
  1443. return request.type.isTextType();
  1444. },
  1445.  
  1446. isPubliclyCacheable: function(request)
  1447. {
  1448. if (this._isExplicitlyNonCacheable(request))
  1449. return false;
  1450.  
  1451. if (this.responseHeaderMatch(request, "Cache-Control", "public"))
  1452. return true;
  1453.  
  1454. return request.url.indexOf("?") == -1 && !this.responseHeaderMatch(request, "Cache-Control", "private");
  1455. },
  1456.  
  1457. responseHeaderMatch: function(request, header, regexp)
  1458. {
  1459. return request.responseHeaderValue(header)
  1460. ? request.responseHeaderValue(header).match(new RegExp(regexp, "im"))
  1461. : undefined;
  1462. },
  1463.  
  1464. hasExplicitExpiration: function(request)
  1465. {
  1466. return this.hasResponseHeader(request, "Date") &&
  1467. (this.hasResponseHeader(request, "Expires") || this.responseHeaderMatch(request, "Cache-Control", "max-age"));
  1468. },
  1469.  
  1470. _isExplicitlyNonCacheable: function(request)
  1471. {
  1472. var hasExplicitExp = this.hasExplicitExpiration(request);
  1473. return this.responseHeaderMatch(request, "Cache-Control", "(no-cache|no-store|must-revalidate)") ||
  1474. this.responseHeaderMatch(request, "Pragma", "no-cache") ||
  1475. (hasExplicitExp && !this.freshnessLifetimeGreaterThan(request, 0)) ||
  1476. (!hasExplicitExp && request.url && request.url.indexOf("?") >= 0) ||
  1477. (!hasExplicitExp && !this.isCacheableResource(request));
  1478. },
  1479.  
  1480. isCacheableResource: function(request)
  1481. {
  1482. return request.statusCode !== undefined && WebInspector.AuditRules.CacheableResponseCodes[request.statusCode];
  1483. },
  1484.  
  1485. __proto__: WebInspector.AuditRule.prototype
  1486. }
  1487.  
  1488.  
  1489. WebInspector.AuditRules.BrowserCacheControlRule = function()
  1490. {
  1491. WebInspector.AuditRules.CacheControlRule.call(this, "http-browsercache", "Leverage browser caching");
  1492. }
  1493.  
  1494. WebInspector.AuditRules.BrowserCacheControlRule.prototype = {
  1495. handleNonCacheableResources: function(requests, result)
  1496. {
  1497. if (requests.length) {
  1498. var entry = result.addChild("The following resources are explicitly non-cacheable. Consider making them cacheable if possible:", true);
  1499. result.violationCount += requests.length;
  1500. for (var i = 0; i < requests.length; ++i)
  1501. entry.addURL(requests[i].url);
  1502. }
  1503. },
  1504.  
  1505. runChecks: function(requests, result, callback)
  1506. {
  1507. this.execCheck("The following resources are missing a cache expiration. Resources that do not specify an expiration may not be cached by browsers:",
  1508. this._missingExpirationCheck, requests, result);
  1509. this.execCheck("The following resources specify a \"Vary\" header that disables caching in most versions of Internet Explorer:",
  1510. this._varyCheck, requests, result);
  1511. this.execCheck("The following cacheable resources have a short freshness lifetime:",
  1512. this._oneMonthExpirationCheck, requests, result);
  1513.  
  1514.  
  1515. this.execCheck("To further improve cache hit rate, specify an expiration one year in the future for the following cacheable resources:",
  1516. this._oneYearExpirationCheck, requests, result);
  1517. },
  1518.  
  1519. _missingExpirationCheck: function(request)
  1520. {
  1521. return this.isCacheableResource(request) && !this.hasResponseHeader(request, "Set-Cookie") && !this.hasExplicitExpiration(request);
  1522. },
  1523.  
  1524. _varyCheck: function(request)
  1525. {
  1526. var varyHeader = this.responseHeader(request, "Vary");
  1527. if (varyHeader) {
  1528. varyHeader = varyHeader.replace(/User-Agent/gi, "");
  1529. varyHeader = varyHeader.replace(/Accept-Encoding/gi, "");
  1530. varyHeader = varyHeader.replace(/[, ]*/g, "");
  1531. }
  1532. return varyHeader && varyHeader.length && this.isCacheableResource(request) && this.freshnessLifetimeGreaterThan(request, 0);
  1533. },
  1534.  
  1535. _oneMonthExpirationCheck: function(request)
  1536. {
  1537. return this.isCacheableResource(request) &&
  1538. !this.hasResponseHeader(request, "Set-Cookie") &&
  1539. !this.freshnessLifetimeGreaterThan(request, WebInspector.AuditRules.CacheControlRule.MillisPerMonth) &&
  1540. this.freshnessLifetimeGreaterThan(request, 0);
  1541. },
  1542.  
  1543. _oneYearExpirationCheck: function(request)
  1544. {
  1545. return this.isCacheableResource(request) &&
  1546. !this.hasResponseHeader(request, "Set-Cookie") &&
  1547. !this.freshnessLifetimeGreaterThan(request, 11 * WebInspector.AuditRules.CacheControlRule.MillisPerMonth) &&
  1548. this.freshnessLifetimeGreaterThan(request, WebInspector.AuditRules.CacheControlRule.MillisPerMonth);
  1549. },
  1550.  
  1551. __proto__: WebInspector.AuditRules.CacheControlRule.prototype
  1552. }
  1553.  
  1554.  
  1555. WebInspector.AuditRules.ProxyCacheControlRule = function() {
  1556. WebInspector.AuditRules.CacheControlRule.call(this, "http-proxycache", "Leverage proxy caching");
  1557. }
  1558.  
  1559. WebInspector.AuditRules.ProxyCacheControlRule.prototype = {
  1560. runChecks: function(requests, result, callback)
  1561. {
  1562. this.execCheck("Resources with a \"?\" in the URL are not cached by most proxy caching servers:",
  1563. this._questionMarkCheck, requests, result);
  1564. this.execCheck("Consider adding a \"Cache-Control: public\" header to the following resources:",
  1565. this._publicCachingCheck, requests, result);
  1566. this.execCheck("The following publicly cacheable resources contain a Set-Cookie header. This security vulnerability can cause cookies to be shared by multiple users.",
  1567. this._setCookieCacheableCheck, requests, result);
  1568. },
  1569.  
  1570. _questionMarkCheck: function(request)
  1571. {
  1572. return request.url.indexOf("?") >= 0 && !this.hasResponseHeader(request, "Set-Cookie") && this.isPubliclyCacheable(request);
  1573. },
  1574.  
  1575. _publicCachingCheck: function(request)
  1576. {
  1577. return this.isCacheableResource(request) &&
  1578. !this.isCompressible(request) &&
  1579. !this.responseHeaderMatch(request, "Cache-Control", "public") &&
  1580. !this.hasResponseHeader(request, "Set-Cookie");
  1581. },
  1582.  
  1583. _setCookieCacheableCheck: function(request)
  1584. {
  1585. return this.hasResponseHeader(request, "Set-Cookie") && this.isPubliclyCacheable(request);
  1586. },
  1587.  
  1588. __proto__: WebInspector.AuditRules.CacheControlRule.prototype
  1589. }
  1590.  
  1591.  
  1592. WebInspector.AuditRules.ImageDimensionsRule = function()
  1593. {
  1594. WebInspector.AuditRule.call(this, "page-imagedims", "Specify image dimensions");
  1595. }
  1596.  
  1597. WebInspector.AuditRules.ImageDimensionsRule.prototype = {
  1598.  
  1599. doRun: function(requests, result, callback, progress)
  1600. {
  1601. var urlToNoDimensionCount = {};
  1602.  
  1603. function doneCallback()
  1604. {
  1605. for (var url in urlToNoDimensionCount) {
  1606. var entry = entry || result.addChild("A width and height should be specified for all images in order to speed up page display. The following image(s) are missing a width and/or height:", true);
  1607. var format = "%r";
  1608. if (urlToNoDimensionCount[url] > 1)
  1609. format += " (%d uses)";
  1610. entry.addFormatted(format, url, urlToNoDimensionCount[url]);
  1611. result.violationCount++;
  1612. }
  1613. callback(entry ? result : null);
  1614. }
  1615.  
  1616. function imageStylesReady(imageId, styles, isLastStyle, computedStyle)
  1617. {
  1618. if (progress.isCanceled())
  1619. return;
  1620.  
  1621. const node = WebInspector.domAgent.nodeForId(imageId);
  1622. var src = node.getAttribute("src");
  1623. if (!src.asParsedURL()) {
  1624. for (var frameOwnerCandidate = node; frameOwnerCandidate; frameOwnerCandidate = frameOwnerCandidate.parentNode) {
  1625. if (frameOwnerCandidate.baseURL) {
  1626. var completeSrc = WebInspector.ParsedURL.completeURL(frameOwnerCandidate.baseURL, src);
  1627. break;
  1628. }
  1629. }
  1630. }
  1631. if (completeSrc)
  1632. src = completeSrc;
  1633.  
  1634. if (computedStyle.getPropertyValue("position") === "absolute") {
  1635. if (isLastStyle)
  1636. doneCallback();
  1637. return;
  1638. }
  1639.  
  1640. if (styles.attributesStyle) {
  1641. var widthFound = !!styles.attributesStyle.getLiveProperty("width");
  1642. var heightFound = !!styles.attributesStyle.getLiveProperty("height");
  1643. }
  1644.  
  1645. var inlineStyle = styles.inlineStyle;
  1646. if (inlineStyle) {
  1647. if (inlineStyle.getPropertyValue("width") !== "")
  1648. widthFound = true;
  1649. if (inlineStyle.getPropertyValue("height") !== "")
  1650. heightFound = true;
  1651. }
  1652.  
  1653. for (var i = styles.matchedCSSRules.length - 1; i >= 0 && !(widthFound && heightFound); --i) {
  1654. var style = styles.matchedCSSRules[i].style;
  1655. if (style.getPropertyValue("width") !== "")
  1656. widthFound = true;
  1657. if (style.getPropertyValue("height") !== "")
  1658. heightFound = true;
  1659. }
  1660.  
  1661. if (!widthFound || !heightFound) {
  1662. if (src in urlToNoDimensionCount)
  1663. ++urlToNoDimensionCount[src];
  1664. else
  1665. urlToNoDimensionCount[src] = 1;
  1666. }
  1667.  
  1668. if (isLastStyle)
  1669. doneCallback();
  1670. }
  1671.  
  1672. function getStyles(nodeIds)
  1673. {
  1674. if (progress.isCanceled())
  1675. return;
  1676. var targetResult = {};
  1677.  
  1678. function inlineCallback(inlineStyle, attributesStyle)
  1679. {
  1680. targetResult.inlineStyle = inlineStyle;
  1681. targetResult.attributesStyle = attributesStyle;
  1682. }
  1683.  
  1684. function matchedCallback(result)
  1685. {
  1686. if (result)
  1687. targetResult.matchedCSSRules = result.matchedCSSRules;
  1688. }
  1689.  
  1690. if (!nodeIds || !nodeIds.length)
  1691. doneCallback();
  1692.  
  1693. for (var i = 0; nodeIds && i < nodeIds.length; ++i) {
  1694. WebInspector.cssModel.getMatchedStylesAsync(nodeIds[i], false, false, matchedCallback);
  1695. WebInspector.cssModel.getInlineStylesAsync(nodeIds[i], inlineCallback);
  1696. WebInspector.cssModel.getComputedStyleAsync(nodeIds[i], imageStylesReady.bind(null, nodeIds[i], targetResult, i === nodeIds.length - 1));
  1697. }
  1698. }
  1699.  
  1700. function onDocumentAvailable(root)
  1701. {
  1702. if (progress.isCanceled())
  1703. return;
  1704. WebInspector.domAgent.querySelectorAll(root.id, "img[src]", getStyles);
  1705. }
  1706.  
  1707. if (progress.isCanceled())
  1708. return;
  1709. WebInspector.domAgent.requestDocument(onDocumentAvailable);
  1710. },
  1711.  
  1712. __proto__: WebInspector.AuditRule.prototype
  1713. }
  1714.  
  1715.  
  1716. WebInspector.AuditRules.CssInHeadRule = function()
  1717. {
  1718. WebInspector.AuditRule.call(this, "page-cssinhead", "Put CSS in the document head");
  1719. }
  1720.  
  1721. WebInspector.AuditRules.CssInHeadRule.prototype = {
  1722.  
  1723. doRun: function(requests, result, callback, progress)
  1724. {
  1725. function evalCallback(evalResult)
  1726. {
  1727. if (progress.isCanceled())
  1728. return;
  1729.  
  1730. if (!evalResult)
  1731. return callback(null);
  1732.  
  1733. var summary = result.addChild("");
  1734.  
  1735. var outputMessages = [];
  1736. for (var url in evalResult) {
  1737. var urlViolations = evalResult[url];
  1738. if (urlViolations[0]) {
  1739. result.addFormatted("%s style block(s) in the %r body should be moved to the document head.", urlViolations[0], url);
  1740. result.violationCount += urlViolations[0];
  1741. }
  1742. for (var i = 0; i < urlViolations[1].length; ++i)
  1743. result.addFormatted("Link node %r should be moved to the document head in %r", urlViolations[1][i], url);
  1744. result.violationCount += urlViolations[1].length;
  1745. }
  1746. summary.value = String.sprintf("CSS in the document body adversely impacts rendering performance.");
  1747. callback(result);
  1748. }
  1749.  
  1750. function externalStylesheetsReceived(root, inlineStyleNodeIds, nodeIds)
  1751. {
  1752. if (progress.isCanceled())
  1753. return;
  1754.  
  1755. if (!nodeIds)
  1756. return;
  1757. var externalStylesheetNodeIds = nodeIds;
  1758. var result = null;
  1759. if (inlineStyleNodeIds.length || externalStylesheetNodeIds.length) {
  1760. var urlToViolationsArray = {};
  1761. var externalStylesheetHrefs = [];
  1762. for (var j = 0; j < externalStylesheetNodeIds.length; ++j) {
  1763. var linkNode = WebInspector.domAgent.nodeForId(externalStylesheetNodeIds[j]);
  1764. var completeHref = WebInspector.ParsedURL.completeURL(linkNode.ownerDocument.baseURL, linkNode.getAttribute("href"));
  1765. externalStylesheetHrefs.push(completeHref || "<empty>");
  1766. }
  1767. urlToViolationsArray[root.documentURL] = [inlineStyleNodeIds.length, externalStylesheetHrefs];
  1768. result = urlToViolationsArray;
  1769. }
  1770. evalCallback(result);
  1771. }
  1772.  
  1773. function inlineStylesReceived(root, nodeIds)
  1774. {
  1775. if (progress.isCanceled())
  1776. return;
  1777.  
  1778. if (!nodeIds)
  1779. return;
  1780. WebInspector.domAgent.querySelectorAll(root.id, "body link[rel~='stylesheet'][href]", externalStylesheetsReceived.bind(null, root, nodeIds));
  1781. }
  1782.  
  1783. function onDocumentAvailable(root)
  1784. {
  1785. if (progress.isCanceled())
  1786. return;
  1787.  
  1788. WebInspector.domAgent.querySelectorAll(root.id, "body style", inlineStylesReceived.bind(null, root));
  1789. }
  1790.  
  1791. WebInspector.domAgent.requestDocument(onDocumentAvailable);
  1792. },
  1793.  
  1794. __proto__: WebInspector.AuditRule.prototype
  1795. }
  1796.  
  1797.  
  1798. WebInspector.AuditRules.StylesScriptsOrderRule = function()
  1799. {
  1800. WebInspector.AuditRule.call(this, "page-stylescriptorder", "Optimize the order of styles and scripts");
  1801. }
  1802.  
  1803. WebInspector.AuditRules.StylesScriptsOrderRule.prototype = {
  1804.  
  1805. doRun: function(requests, result, callback, progress)
  1806. {
  1807. function evalCallback(resultValue)
  1808. {
  1809. if (progress.isCanceled())
  1810. return;
  1811.  
  1812. if (!resultValue)
  1813. return callback(null);
  1814.  
  1815. var lateCssUrls = resultValue[0];
  1816. var cssBeforeInlineCount = resultValue[1];
  1817.  
  1818. var entry = result.addChild("The following external CSS files were included after an external JavaScript file in the document head. To ensure CSS files are downloaded in parallel, always include external CSS before external JavaScript.", true);
  1819. entry.addURLs(lateCssUrls);
  1820. result.violationCount += lateCssUrls.length;
  1821.  
  1822. if (cssBeforeInlineCount) {
  1823. result.addChild(String.sprintf(" %d inline script block%s found in the head between an external CSS file and another resource. To allow parallel downloading, move the inline script before the external CSS file, or after the next resource.", cssBeforeInlineCount, cssBeforeInlineCount > 1 ? "s were" : " was"));
  1824. result.violationCount += cssBeforeInlineCount;
  1825. }
  1826. callback(result);
  1827. }
  1828.  
  1829. function cssBeforeInlineReceived(lateStyleIds, nodeIds)
  1830. {
  1831. if (progress.isCanceled())
  1832. return;
  1833.  
  1834. if (!nodeIds)
  1835. return;
  1836.  
  1837. var cssBeforeInlineCount = nodeIds.length;
  1838. var result = null;
  1839. if (lateStyleIds.length || cssBeforeInlineCount) {
  1840. var lateStyleUrls = [];
  1841. for (var i = 0; i < lateStyleIds.length; ++i) {
  1842. var lateStyleNode = WebInspector.domAgent.nodeForId(lateStyleIds[i]);
  1843. var completeHref = WebInspector.ParsedURL.completeURL(lateStyleNode.ownerDocument.baseURL, lateStyleNode.getAttribute("href"));
  1844. lateStyleUrls.push(completeHref || "<empty>");
  1845. }
  1846. result = [ lateStyleUrls, cssBeforeInlineCount ];
  1847. }
  1848.  
  1849. evalCallback(result);
  1850. }
  1851.  
  1852. function lateStylesReceived(root, nodeIds)
  1853. {
  1854. if (progress.isCanceled())
  1855. return;
  1856.  
  1857. if (!nodeIds)
  1858. return;
  1859.  
  1860. WebInspector.domAgent.querySelectorAll(root.id, "head link[rel~='stylesheet'][href] ~ script:not([src])", cssBeforeInlineReceived.bind(null, nodeIds));
  1861. }
  1862.  
  1863. function onDocumentAvailable(root)
  1864. {
  1865. if (progress.isCanceled())
  1866. return;
  1867.  
  1868. WebInspector.domAgent.querySelectorAll(root.id, "head script[src] ~ link[rel~='stylesheet'][href]", lateStylesReceived.bind(null, root));
  1869. }
  1870.  
  1871. WebInspector.domAgent.requestDocument(onDocumentAvailable);
  1872. },
  1873.  
  1874. __proto__: WebInspector.AuditRule.prototype
  1875. }
  1876.  
  1877.  
  1878. WebInspector.AuditRules.CSSRuleBase = function(id, name)
  1879. {
  1880. WebInspector.AuditRule.call(this, id, name);
  1881. }
  1882.  
  1883. WebInspector.AuditRules.CSSRuleBase.prototype = {
  1884.  
  1885. doRun: function(requests, result, callback, progress)
  1886. {
  1887. CSSAgent.getAllStyleSheets(sheetsCallback.bind(this));
  1888.  
  1889. function sheetsCallback(error, headers)
  1890. {
  1891. if (error)
  1892. return callback(null);
  1893.  
  1894. if (!headers.length)
  1895. return callback(null);
  1896. for (var i = 0; i < headers.length; ++i) {
  1897. var header = headers[i];
  1898. if (header.disabled)
  1899. continue; 
  1900.  
  1901. this._visitStyleSheet(header.styleSheetId, i === headers.length - 1 ? finishedCallback : null, result, progress);
  1902. }
  1903. }
  1904.  
  1905. function finishedCallback()
  1906. {
  1907. callback(result);
  1908. }
  1909. },
  1910.  
  1911. _visitStyleSheet: function(styleSheetId, callback, result, progress)
  1912. {
  1913. WebInspector.CSSStyleSheet.createForId(styleSheetId, sheetCallback.bind(this));
  1914.  
  1915. function sheetCallback(styleSheet)
  1916. {
  1917. if (progress.isCanceled())
  1918. return;
  1919.  
  1920. if (!styleSheet) {
  1921. if (callback)
  1922. callback();
  1923. return;
  1924. }
  1925.  
  1926. this.visitStyleSheet(styleSheet, result);
  1927.  
  1928. for (var i = 0; i < styleSheet.rules.length; ++i)
  1929. this._visitRule(styleSheet, styleSheet.rules[i], result);
  1930.  
  1931. this.didVisitStyleSheet(styleSheet, result);
  1932.  
  1933. if (callback)
  1934. callback();
  1935. }
  1936. },
  1937.  
  1938. _visitRule: function(styleSheet, rule, result)
  1939. {
  1940. this.visitRule(styleSheet, rule, result);
  1941. var allProperties = rule.style.allProperties;
  1942. for (var i = 0; i < allProperties.length; ++i)
  1943. this.visitProperty(styleSheet, allProperties[i], result);
  1944. this.didVisitRule(styleSheet, rule, result);
  1945. },
  1946.  
  1947. visitStyleSheet: function(styleSheet, result)
  1948. {
  1949.  
  1950. },
  1951.  
  1952. didVisitStyleSheet: function(styleSheet, result)
  1953. {
  1954.  
  1955. },
  1956.  
  1957. visitRule: function(styleSheet, rule, result)
  1958. {
  1959.  
  1960. },
  1961.  
  1962. didVisitRule: function(styleSheet, rule, result)
  1963. {
  1964.  
  1965. },
  1966.  
  1967. visitProperty: function(styleSheet, property, result)
  1968. {
  1969.  
  1970. },
  1971.  
  1972. __proto__: WebInspector.AuditRule.prototype
  1973. }
  1974.  
  1975.  
  1976. WebInspector.AuditRules.VendorPrefixedCSSProperties = function()
  1977. {
  1978. WebInspector.AuditRules.CSSRuleBase.call(this, "page-vendorprefixedcss", "Use normal CSS property names instead of vendor-prefixed ones");
  1979. this._webkitPrefix = "-webkit-";
  1980. }
  1981.  
  1982. WebInspector.AuditRules.VendorPrefixedCSSProperties.supportedProperties = [
  1983. "background-clip", "background-origin", "background-size",
  1984. "border-radius", "border-bottom-left-radius", "border-bottom-right-radius", "border-top-left-radius", "border-top-right-radius",
  1985. "box-shadow", "box-sizing", "opacity", "text-shadow"
  1986. ].keySet();
  1987.  
  1988. WebInspector.AuditRules.VendorPrefixedCSSProperties.prototype = {
  1989. didVisitStyleSheet: function(styleSheet)
  1990. {
  1991. delete this._styleSheetResult;
  1992. },
  1993.  
  1994. visitRule: function(rule)
  1995. {
  1996. this._mentionedProperties = {};
  1997. },
  1998.  
  1999. didVisitRule: function()
  2000. {
  2001. delete this._ruleResult;
  2002. delete this._mentionedProperties;
  2003. },
  2004.  
  2005. visitProperty: function(styleSheet, property, result)
  2006. {
  2007. if (!property.name.startsWith(this._webkitPrefix))
  2008. return;
  2009.  
  2010. var normalPropertyName = property.name.substring(this._webkitPrefix.length).toLowerCase(); 
  2011. if (WebInspector.AuditRules.VendorPrefixedCSSProperties.supportedProperties[normalPropertyName] && !this._mentionedProperties[normalPropertyName]) {
  2012. var style = property.ownerStyle;
  2013. var liveProperty = style.getLiveProperty(normalPropertyName);
  2014. if (liveProperty && !liveProperty.styleBased)
  2015. return; 
  2016.  
  2017. var rule = style.parentRule;
  2018. this._mentionedProperties[normalPropertyName] = true;
  2019. if (!this._styleSheetResult)
  2020. this._styleSheetResult = result.addChild(rule.sourceURL ? WebInspector.linkifyResourceAsNode(rule.sourceURL) : "<unknown>");
  2021. if (!this._ruleResult) {
  2022. var anchor = WebInspector.linkifyURLAsNode(rule.sourceURL, rule.selectorText);
  2023. anchor.preferredPanel = "resources";
  2024. anchor.lineNumber = rule.sourceLine;
  2025. this._ruleResult = this._styleSheetResult.addChild(anchor);
  2026. }
  2027. ++result.violationCount;
  2028. this._ruleResult.addSnippet(String.sprintf("\"" + this._webkitPrefix + "%s\" is used, but \"%s\" is supported.", normalPropertyName, normalPropertyName));
  2029. }
  2030. },
  2031.  
  2032. __proto__: WebInspector.AuditRules.CSSRuleBase.prototype
  2033. }
  2034.  
  2035.  
  2036. WebInspector.AuditRules.CookieRuleBase = function(id, name)
  2037. {
  2038. WebInspector.AuditRule.call(this, id, name);
  2039. }
  2040.  
  2041. WebInspector.AuditRules.CookieRuleBase.prototype = {
  2042.  
  2043. doRun: function(requests, result, callback, progress)
  2044. {
  2045. var self = this;
  2046. function resultCallback(receivedCookies, isAdvanced) {
  2047. if (progress.isCanceled())
  2048. return;
  2049.  
  2050. self.processCookies(isAdvanced ? receivedCookies : [], requests, result);
  2051. callback(result);
  2052. }
  2053.  
  2054. WebInspector.Cookies.getCookiesAsync(resultCallback);
  2055. },
  2056.  
  2057. mapResourceCookies: function(requestsByDomain, allCookies, callback)
  2058. {
  2059. for (var i = 0; i < allCookies.length; ++i) {
  2060. for (var requestDomain in requestsByDomain) {
  2061. if (WebInspector.Cookies.cookieDomainMatchesResourceDomain(allCookies[i].domain(), requestDomain))
  2062. this._callbackForResourceCookiePairs(requestsByDomain[requestDomain], allCookies[i], callback);
  2063. }
  2064. }
  2065. },
  2066.  
  2067. _callbackForResourceCookiePairs: function(requests, cookie, callback)
  2068. {
  2069. if (!requests)
  2070. return;
  2071. for (var i = 0; i < requests.length; ++i) {
  2072. if (WebInspector.Cookies.cookieMatchesResourceURL(cookie, requests[i].url))
  2073. callback(requests[i], cookie);
  2074. }
  2075. },
  2076.  
  2077. __proto__: WebInspector.AuditRule.prototype
  2078. }
  2079.  
  2080.  
  2081. WebInspector.AuditRules.CookieSizeRule = function(avgBytesThreshold)
  2082. {
  2083. WebInspector.AuditRules.CookieRuleBase.call(this, "http-cookiesize", "Minimize cookie size");
  2084. this._avgBytesThreshold = avgBytesThreshold;
  2085. this._maxBytesThreshold = 1000;
  2086. }
  2087.  
  2088. WebInspector.AuditRules.CookieSizeRule.prototype = {
  2089. _average: function(cookieArray)
  2090. {
  2091. var total = 0;
  2092. for (var i = 0; i < cookieArray.length; ++i)
  2093. total += cookieArray[i].size();
  2094. return cookieArray.length ? Math.round(total / cookieArray.length) : 0;
  2095. },
  2096.  
  2097. _max: function(cookieArray)
  2098. {
  2099. var result = 0;
  2100. for (var i = 0; i < cookieArray.length; ++i)
  2101. result = Math.max(cookieArray[i].size(), result);
  2102. return result;
  2103. },
  2104.  
  2105. processCookies: function(allCookies, requests, result)
  2106. {
  2107. function maxSizeSorter(a, b)
  2108. {
  2109. return b.maxCookieSize - a.maxCookieSize;
  2110. }
  2111.  
  2112. function avgSizeSorter(a, b)
  2113. {
  2114. return b.avgCookieSize - a.avgCookieSize;
  2115. }
  2116.  
  2117. var cookiesPerResourceDomain = {};
  2118.  
  2119. function collectorCallback(request, cookie)
  2120. {
  2121. var cookies = cookiesPerResourceDomain[request.parsedURL.host];
  2122. if (!cookies) {
  2123. cookies = [];
  2124. cookiesPerResourceDomain[request.parsedURL.host] = cookies;
  2125. }
  2126. cookies.push(cookie);
  2127. }
  2128.  
  2129. if (!allCookies.length)
  2130. return;
  2131.  
  2132. var sortedCookieSizes = [];
  2133.  
  2134. var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(requests,
  2135. null,
  2136. true);
  2137. var matchingResourceData = {};
  2138. this.mapResourceCookies(domainToResourcesMap, allCookies, collectorCallback.bind(this));
  2139.  
  2140. for (var requestDomain in cookiesPerResourceDomain) {
  2141. var cookies = cookiesPerResourceDomain[requestDomain];
  2142. sortedCookieSizes.push({
  2143. domain: requestDomain,
  2144. avgCookieSize: this._average(cookies),
  2145. maxCookieSize: this._max(cookies)
  2146. });
  2147. }
  2148. var avgAllCookiesSize = this._average(allCookies);
  2149.  
  2150. var hugeCookieDomains = [];
  2151. sortedCookieSizes.sort(maxSizeSorter);
  2152.  
  2153. for (var i = 0, len = sortedCookieSizes.length; i < len; ++i) {
  2154. var maxCookieSize = sortedCookieSizes[i].maxCookieSize;
  2155. if (maxCookieSize > this._maxBytesThreshold)
  2156. hugeCookieDomains.push(WebInspector.AuditRuleResult.resourceDomain(sortedCookieSizes[i].domain) + ": " + Number.bytesToString(maxCookieSize));
  2157. }
  2158.  
  2159. var bigAvgCookieDomains = [];
  2160. sortedCookieSizes.sort(avgSizeSorter);
  2161. for (var i = 0, len = sortedCookieSizes.length; i < len; ++i) {
  2162. var domain = sortedCookieSizes[i].domain;
  2163. var avgCookieSize = sortedCookieSizes[i].avgCookieSize;
  2164. if (avgCookieSize > this._avgBytesThreshold && avgCookieSize < this._maxBytesThreshold)
  2165. bigAvgCookieDomains.push(WebInspector.AuditRuleResult.resourceDomain(domain) + ": " + Number.bytesToString(avgCookieSize));
  2166. }
  2167. result.addChild(String.sprintf("The average cookie size for all requests on this page is %s", Number.bytesToString(avgAllCookiesSize)));
  2168.  
  2169. var message;
  2170. if (hugeCookieDomains.length) {
  2171. var entry = result.addChild("The following domains have a cookie size in excess of 1KB. This is harmful because requests with cookies larger than 1KB typically cannot fit into a single network packet.", true);
  2172. entry.addURLs(hugeCookieDomains);
  2173. result.violationCount += hugeCookieDomains.length;
  2174. }
  2175.  
  2176. if (bigAvgCookieDomains.length) {
  2177. var entry = result.addChild(String.sprintf("The following domains have an average cookie size in excess of %d bytes. Reducing the size of cookies for these domains can reduce the time it takes to send requests.", this._avgBytesThreshold), true);
  2178. entry.addURLs(bigAvgCookieDomains);
  2179. result.violationCount += bigAvgCookieDomains.length;
  2180. }
  2181. },
  2182.  
  2183. __proto__: WebInspector.AuditRules.CookieRuleBase.prototype
  2184. }
  2185.  
  2186.  
  2187. WebInspector.AuditRules.StaticCookielessRule = function(minResources)
  2188. {
  2189. WebInspector.AuditRules.CookieRuleBase.call(this, "http-staticcookieless", "Serve static content from a cookieless domain");
  2190. this._minResources = minResources;
  2191. }
  2192.  
  2193. WebInspector.AuditRules.StaticCookielessRule.prototype = {
  2194. processCookies: function(allCookies, requests, result)
  2195. {
  2196. var domainToResourcesMap = WebInspector.AuditRules.getDomainToResourcesMap(requests,
  2197. [WebInspector.resourceTypes.Stylesheet,
  2198. WebInspector.resourceTypes.Image],
  2199. true);
  2200. var totalStaticResources = 0;
  2201. for (var domain in domainToResourcesMap)
  2202. totalStaticResources += domainToResourcesMap[domain].length;
  2203. if (totalStaticResources < this._minResources)
  2204. return;
  2205. var matchingResourceData = {};
  2206. this.mapResourceCookies(domainToResourcesMap, allCookies, this._collectorCallback.bind(this, matchingResourceData));
  2207.  
  2208. var badUrls = [];
  2209. var cookieBytes = 0;
  2210. for (var url in matchingResourceData) {
  2211. badUrls.push(url);
  2212. cookieBytes += matchingResourceData[url]
  2213. }
  2214. if (badUrls.length < this._minResources)
  2215. return;
  2216.  
  2217. var entry = result.addChild(String.sprintf("%s of cookies were sent with the following static resources. Serve these static resources from a domain that does not set cookies:", Number.bytesToString(cookieBytes)), true);
  2218. entry.addURLs(badUrls);
  2219. result.violationCount = badUrls.length;
  2220. },
  2221.  
  2222. _collectorCallback: function(matchingResourceData, request, cookie)
  2223. {
  2224. matchingResourceData[request.url] = (matchingResourceData[request.url] || 0) + cookie.size();
  2225. },
  2226.  
  2227. __proto__: WebInspector.AuditRules.CookieRuleBase.prototype
  2228. }
  2229. ;
  2230.